import { arrayObjectDeDuplication } from '@/utils/commonUtils/HLUtils'
import { methodGetApi } from '@/api/publicApi'
import { returnPath } from '@/utils/commonUtils/HLUtils'
export const commonMixins = {
  data() {
    return {
      // 公共---------------start-------------------------------------------------------------
      normalizerObj: { id: 'id', label: 'name' }, // treeSelect转换字段初始值,如果不是初始值，请在独立页面中使用normalizer转换
      treeParamData: {}, // treeSelect接口入参初始值
      // 公共---------------end---------------------------------------------------------------

      // 系统数据--------api数据--------------------start---------------------------------------
      deptOptions: [], // 部门树选项
      // 系统数据--------api数据---------------------end----------------------------------------

      // 系统公共----必加不删----字典数据--------------------start--------------------------------
      sysUserSexOptions: [], // 性别 字典数据（0：男 / 1： 女 / 2：未知）
      sysShowHideOptions: [], // 菜单状态 字典数据（0：显示 / 1： 隐藏）
      sysNormalDisableOptions: [], // 系统开关 字典数据（0：正常 / 1： 停用）
      sysYesNoOptions: [], // 系统是否 字典数据（Y：是 / N： 否）
      sysOperTypeOptions: [], // 操作类型 字典数据（日志管理所用）
      sysLayoutTypeOptions: [], // 布局类型 字典数据（Layout：平铺布局 / UDLayout：上下布局 / LRLayout ：左右布局）
      newsReleaseStatusOptions: [] // 新闻状态 字典数据（00：待发布 /  01：已发布 / 02：已下线）
      // 系统数据----必加不删----字典数据--------------------end----------------------------------

    }
  },
  computed: {

  },
  created() {
  },
  methods: {
    // 公共---------------start------------------------------------------
    /**
     * @description:  调取数据字典返回对应的数据
     * @Author: baoxuhui
     * @param {*} arrayKey//数组数据Key
     * @param {*} dictType//数据字典的type
     * @return {*}
     */
    getDictMixins(arrayKey, dictType) {
      this[arrayKey] = []
      const url = '/system/dict/data/type/' + dictType
      methodGetApi(url).then(res => {
        this[arrayKey] = res.data
      })
    },

    /**
     * @description:  调取数据字典返回对应的数据
     * @Author: baoxuhui
     * @param {*} arrayKey//数组数据Key
     * @param {*} objData // 自定义 数组数据
     * @return {*}
     */
    getDictAddObjMixins(arrayKey, dictType, objArrData) {
      this[arrayKey] = []
      const url = '/system/dict/data/type/' + dictType
      methodGetApi(url).then(res => {
        this[arrayKey] = objArrData.concat(res.data)
      })
    },

    /**
     * @description: 前端自定义字典转换汉字-通过key获取对应汉字（包含数据字典，静态数组）
     * @Author: baoxuhui
     * @param {*} arrayKey//数组数据Key
     * @param {*} val//需要做参考的数据
     * @param {*} valArrBool//需要做参考的数据是否为数组  默认false
     * @param {*} keyObj//需要转换的key   默认 dictLabel = 'dictLabel',dictValue = 'dictValue'
     * @return {*}
     */
    getDictLabelMixins(arrayKey, val, valArrBool, keyObj) {
      const dictLabel = keyObj ? keyObj.dictLabel : 'dictLabel'
      const dictValue = keyObj ? keyObj.dictValue : 'dictValue'
      let newLabel = null
      if (valArrBool) {
        const newLabelArr = []
        this[arrayKey].forEach(element => {
          val.forEach(eleme => {
            if (element[dictValue] === eleme) {
              newLabelArr.push(element[dictLabel])
            }
          })
        })
        newLabel = newLabelArr.toString()
      } else {
        this[arrayKey].forEach(element => {
          if (element[dictValue] === val) {
            newLabel = element[dictLabel]
          }
        })
      }
      // console.log(newLabel)
      return newLabel
    },

    /**
     * @description: 调取接口返回对应的数据
     * @Author: baoxuhui
     * @param {*} arrayKey//数组数据Key
     * @param {*} url//接口路径
     * @param {*} data//接口入参
     * @return {*}
     */
    getOptionsMixins(arrayKey, url, data) {
      return new Promise((resolve) => {
        this[arrayKey] = []
        methodGetApi(url, data).then(res => {
          const data = res.data ? res.data : res.roles ? res.roles : res.rows
          this[arrayKey] = data
          resolve()
        })
      })
    },

    /**
     * @description:  查询treeSelect懒加载数据
     * @Author: baoxuhui
     * @param {*} optionsName//下拉框options的数据名称
     * @param {*} url//接口路径
     * @param {*} normalizerObj//需要重构的字段名数据结构  默认 { id: 'id', label: 'name' }  例如：{ id: 'menuId', label: 'menuName' }
     * @param {*} paramData//接口入参 例如：{parentId:parentNode.id}
     * @return {*}
     */
    getTreeSelectLazyMixins(optionsName, url, normalizerObj, paramData) {
      return new Promise((resolve) => {
        let newInfoData = this.normalizerObj
        let newParamData = this.treeParamData
        if (this.sentencedEmpty(normalizerObj)) {
          newInfoData = normalizerObj
        }
        if (this.sentencedEmpty(paramData)) {
          newParamData = paramData
        }
        const optionsArr = []

        methodGetApi(url, newParamData).then(res => {
          const resData = res.data
          for (var i = 0; i < resData.length; i++) {
            const resDataInfo = {}
            for (const key in newInfoData) {
              resDataInfo[key] = resData[i][newInfoData[key]]
            }
            // 主要就是为了添加 children = null
            if (resData[i].hasChildren) {
              resDataInfo.children = null
            }
            optionsArr.push(resDataInfo)
          }
          if (this.sentencedEmpty(optionsName)) {
            this[optionsName] = optionsArr
          }
          resolve(optionsArr)
        })
      })
    },

    /**
     * @description: treeSelect懒加载Option   特注：treeSelect懒加载数据回显时需要后端提供父级id数组
     * @Author: baoxuhui
     * @param {*} actionhistroy
     * @param {*} parentNode
     * @param {*} callback
     * @param {*} url//接口路径
     * @param {*} normalizerObj//需要重构的字段名数据结构  默认 { id: 'id', label: 'name' }  例如：{ id: 'menuId', label: 'menuName' }
     * @param {*} paramData//接口入参 例如：{parentId:parentNode.id}
     * @return {*}
     */
    loadOptionsMixins({ action, parentNode, callback }, url, normalizerObj, paramData) {
      let newInfoData = this.normalizerObj
      let newParamData = this.treeParamData
      if (this.sentencedEmpty(normalizerObj)) {
        newInfoData = normalizerObj
      }
      if (this.sentencedEmpty(paramData)) {
        newParamData = paramData
      }
      if (action === 'LOAD_CHILDREN_OPTIONS') {
        methodGetApi(url, newParamData).then(res => {
				  const arrList = []
          const data = res.data
          if (data.length > 0) {
            for (var i = 0; i < data.length; i++) {
              const resDataInfo = {}

              for (const key in newInfoData) {
                resDataInfo[key] = data[i][newInfoData[key]]
              }
              // 主要就是为了添加 children = null
              if (data[i].hasChildren) {
                resDataInfo.children = null
              }
              arrList.push(resDataInfo)
            }
          }
          parentNode.children = arrList
        })
        callback()
      }
    },
    /**
     * @description: 查询数据并重构tree数据
     * @Author: baoxuhui
     * @param {*} optionsName//下拉框options的数据名称
     * @param {*} url//接口路径
     * @param {*} paramData//接口入参 例如：{parentId:parentNode.id}
      * @param {*} treeId//树形结构的Id
      * @param {*} normalizerObj//需要重构的字段名数据结构  默认{}
     * @return {*}
     */
    getTreeSelectMixins(optionsName, url, paramData, treeId, normalizerObj) {
      methodGetApi(url, paramData).then(response => {
        this[optionsName] = []
        if (this.sentencedEmpty(normalizerObj)) {
          normalizerObj.children = this.handleTree(response.data, treeId)
          this[optionsName].push(normalizerObj)
        } else {
          this[optionsName] = this.handleTree(response.data, treeId)
        }
      })
    },
    /**
     * @description:数据中有附件时补全附件所需字段返回处理的数据
     * @Author: baoxuhui
     * @param {*} array //删除的数组
     * @param {*} isMoreChildArr //  是否多子集数组
     * @return {*}
     */
    filesArryMixins(array, isMoreChildArr = false) {
      array.deleteAnnexIds = []
      this.AnnexList.forEach(element => {
        array[element + 'Ids'] = []
        if (array[element + 'List'].length > 0) {
          array[element + 'List'].forEach(eleme => {
            returnPath(eleme.annexPath).then((ress) => {
              eleme.annexPath = ress
            })
            array[element + 'Ids'].push(eleme.id)
            eleme.editBool = true
          })
        } else {
          array[element + 'List'] = []
        }
      })

      if (isMoreChildArr) {
        this.AnnexArrNameList.forEach((item) => {
          item.objNextImgName.forEach((element) => {
            array[item.objNextName].forEach((e) => {
              e[element + 'Ids'] = []
              if (e[element + 'List'] && e[element + 'List'].length > 0) {
                e[element + 'List'].forEach(eleme => {
                  returnPath(eleme.annexPath).then((ress) => {
                    eleme.annexPath = ress
                  })
                  e[element + 'Ids'].push(eleme.id)
                  e.editBool = true
                })
              } else {
                e[element + 'List'] = []
              }
            })
          })
        })
      }
      return array
    },
    /**
     * @description: 公共跳界面
     * @param {*} path//跳转的路由
     * @param {*} queryParams//路径的跟参
     * @param {*} destHistroyPath//是否销毁当前路径   默认销毁  true,false
     * @return {*}
     */
    jumpRouterMixins(path, queryParams, destHistroyPath) {
      let newDestHistroyPath = true
      if (this.sentencedEmpty(destHistroyPath)) {
        newDestHistroyPath = destHistroyPath
      }
      if (newDestHistroyPath) {
        this.$store.dispatch('tagsView/delView', this.$route) // 销毁当前界面
      }
      this.$router.push({ path: path, query: queryParams })
    },
    /**
     * @description:  列表多选框选中数据(当前函数可回调，用于特殊处理)
     * @Author: baoxuhui
     * @param {*} row//判断值的obj
     * @param {*} selectCode//obj种的对比key
     * @param {*} selectTableList//塞值 的数组key
     * @param {*} type//单选或多选   单选：radio,复选：checkbox 默认：checkbox
     * @return {*}
     */
    handleSelectionChangeMixins(row, selectCode, selectTableList, type) {
      return new Promise(resolve => {
        if (type === 'radio') {
          this[selectTableList] = []
          this[selectTableList].push(row)
        } else {
          this[selectTableList] = arrayObjectDeDuplication(row, selectCode)
        }
        resolve(this[selectTableList])
      })
    },
    /**
     * @description: table 附件集合渲染
     * @Author: baoxuhui
     * @param {*} data // 上传成功后回来的数组
     * @param {*} isMoreChildArr // 是否多子集数组
     * @param {*} objName // 数据来源的对象
     * @param {*} objNextName // 数据来源的对象下的数组名
     * @param {*} objNextindex // 数据来源的对象下的数组下的下标
     * @param {*} typeName // 附件前缀
     * @param {*} multiple // 是否为多项
     * @param {*} type // 数组去重 附件中 identifier 唯一码
     * @param {*} isBackShow // 是否回显文件名称
     * @param {*} keyName // 文件名称的key
     * @return {*}
     */
    getFileTableListMixins(data, isMoreChildArr = false, objName, objNextName, objNextindex, typeName, multiple, type, isBackShow, keyName) {
      console.log(data, objName, 111)
      returnPath(data.annexPath).then((ress) => {
        data.annexPath = ress
      })

      if (isMoreChildArr) { // 如： form.arr[0].imageList
        // 判断附件是否多个上传 并将附件置空
        if (!multiple && this[objName][objNextName][objNextindex][typeName + 'List'].length > 0) {
          if (!this.sentencedEmpty(this[objName].deleteAnnexIds)) {
            this[objName].deleteAnnexIds = []
          }
          this[objName].deleteAnnexIds.push(this[objName][objNextName][objNextindex][typeName + 'Ids'][0])
          this[objName][objNextName][objNextindex][typeName + 'List'] = []
          this[objName][objNextName][objNextindex][typeName + 'Ids'] = []
        }
        this[objName][objNextName][objNextindex][typeName + 'List'].push(data)
        this[objName][objNextName][objNextindex][typeName + 'Ids'].push(data.id)
        console.log(this[objName], '附件集合渲染')

        // 处理数据 去重 保留最新上传数据
        if (type && type != 'image') {
          // 处理数据 去重 保留最新上传数据
          this[objName][objNextName][objNextindex][typeName + 'List'] = this.rrayUnique(this[objName][objNextName][objNextindex][typeName + 'List'], 'identifier')
          // 更具去重数据 重新 组装ids
          var arr = []
          this[objName][objNextName][objNextindex][typeName + 'List'].forEach((item, index) => {
            arr.push(item.id)
          })
          this[objName][objNextName][objNextindex][typeName + 'Ids'] = arr
        }

        // 回显附件名称
        if (isBackShow && isBackShow == true) {
          this[objName][objNextName][objNextindex][keyName] = data.annexName.split('.')[0]
        }
        this.$refs[objName].clearValidate(objNextName + '.' + typeName + 'Ids')
      } else { // 如： form.imageList
        // 判断附件是否多个上传 并将附件置空
        if (!multiple && this[objName][typeName + 'List'].length > 0) {
          if (!this.sentencedEmpty(this[objName].deleteAnnexIds)) {
            this[objName].deleteAnnexIds = []
          }
          this[objName].deleteAnnexIds.push(this[objName][typeName + 'Ids'][0])
          this[objName][typeName + 'List'] = []
          this[objName][typeName + 'Ids'] = []
        }
        this[objName][typeName + 'List'].push(data)
        this[objName][typeName + 'Ids'].push(data.id)
        console.log(this[objName], '附件集合渲染')

        // 处理数据 去重 保留最新上传数据
        if (type && type != 'image') {
          // 处理数据 去重 保留最新上传数据
          this[objName][typeName + 'List'] = this.rrayUnique(this[objName][typeName + 'List'], 'identifier')
          // 更具去重数据 重新 组装ids
          var arr = []
          this[objName][typeName + 'List'].forEach((item, index) => {
            arr.push(item.id)
          })
          this[objName][typeName + 'Ids'] = arr
        }

        // 回显附件名称
        if (isBackShow && isBackShow == true) {
          this[objName][keyName] = data.annexName.split('.')[0]
        }
        this.$refs[objName].clearValidate(typeName + 'Ids')
      }
    },
    /**
     * @description: 删除 table 附件集合
     * @Author: baoxuhui
     * @param {*} data // 删除的数组
     * @param {*} deleteAnnexIdsBool // 删除的id
     * @param {*} isMoreChildArr // 是否多子集数组
     * @param {*} objName //数据来源的对象
     * @param {*} objNextName // 数据来源的对象下的数组名
     * @param {*} objNextindex // 数据来源的对象下的数组下的下标
     * @param {*} typeName // 附件前缀
     * @return {*}
     */
    deleteFileTablelistMixins(data, deleteAnnexIdsBool, isMoreChildArr = false, objName, objNextName, objNextindex, typeName, ) {
      // console.log(data)
      // console.log(deleteAnnexIdsBool)
      // console.log(objName)
      // console.log(typeName)
      if (this.sentencedEmpty(deleteAnnexIdsBool)) {
        this[objName].deleteAnnexIds.push(data.id)
      }
      if (isMoreChildArr) { // 如： form.arr[0].imageList
        this[objName][objNextName][objNextindex][typeName + 'Ids'].forEach((element, i) => {
          if (data.id === element) {
            this[objName][objNextName][objNextindex][typeName + 'Ids'].splice(i, 1)
          }
        })
        this[objName][objNextName][objNextindex][typeName + 'List'].forEach((element, i) => {
          if (data.id === element.id) {
            this[objName][objNextName][objNextindex][typeName + 'List'].splice(i, 1)
          }
        })
      } else { // 如： form.imageList
        this[objName][typeName + 'Ids'].forEach((element, i) => {
          if (data.id === element) {
            this[objName][typeName + 'Ids'].splice(i, 1)
          }
        })
        this[objName][typeName + 'List'].forEach((element, i) => {
          if (data.id === element.id) {
            this[objName][typeName + 'List'].splice(i, 1)
          }
        })
      }
    },

    /**
     * @description: Table 附件 回显处理
     * @author: 包旭慧
     * @param {*} data 附件数据
     * @param {*} typeName 附件兼职名 前缀不固定
     * @return {*}
     */
    handelFileTablelistMixin(data, typeName) {
      data[typeName + 'Ids'] = []
      if (data[typeName + 'List'].length != 0) {
        data[typeName + 'List'].forEach((item) => {
          data[typeName + 'Ids'].push(item.id)
        })
      }
    }

    // 公共---------------end------------------------------------------

  }
}
